const { Service } = require('egg');
const { Op } = require('sequelize');

class JobService extends Service {
  // 获取职位列表（核心修改）
  async list({ page = 1, pageSize = 10, keyword, ...otherWhere }) {
    const { ctx } = this;
    const offset = (page - 1) * pageSize;
    
    // 构建查询条件
    const where = {};
    
    // 1. 关键词模糊搜索（匹配职位标题和公司名称，模型中存在的字段）
    if (keyword && keyword.trim() !== '') {
      where[Op.or] = [
        { title: { [Op.like]: `%${keyword.trim()}%` } }, // 匹配职位标题
        { company: { [Op.like]: `%${keyword.trim()}%` } } // 匹配公司名称（模型中存在company字段）
      ];
    }
    
    // 2. 处理其他筛选参数：只保留模型中存在的字段（company、location）
    // 白名单：仅允许筛选模型中已定义的字段，防止传递无效字段（如type）导致SQL错误
    const allowedFields = ['company', 'location', 'title'];  // 模型中存在的筛选字段
    Object.keys(otherWhere).forEach(key => {
      // 只处理白名单内的字段
      if (!allowedFields.includes(key)) return;
      
      const value = otherWhere[key];
      // 仅当值有效时（非空/非undefined）才添加到查询条件
      if (value !== '' && value !== undefined && value !== null) {
        where[key] = { [Op.like]: `%${value}%` }
      }
    });
    
    // 执行查询（使用处理后的条件）
    const { count, rows } = await ctx.model.Job.findAndCountAll({
      where,
      limit: pageSize,
      offset,
      order: [['created_at', 'DESC']],
    });
    
    return {
      list: rows,
      pagination: {
        total: count,
        page: Number(page),
        pageSize: Number(pageSize),
        totalPages: Math.ceil(count / pageSize),
      },
    };
  }

  // 根据ID获取职位（不变）
  async findById(id) {
    const { ctx } = this;
    return ctx.model.Job.findByPk(id);
  }

  // 更新职位（不变）
  async update(id, data) {
    const { ctx } = this;
    const job = await ctx.model.Job.findByPk(id);
    if (!job) {
      throw new Error('职位不存在');
    }

    const currentUserId = ctx.state.user_id;
    if (!currentUserId) {
      throw new Error('请先登录');
    }

    const isAdmin = ctx.state.type === 'admin';
    if (!isAdmin && job.publisher_id.toString() !== currentUserId.toString()) {
      throw new Error('无权修改此职位（非发布者或管理员）');
    }

    await job.update({ ...data, updated_at: new Date() });
    return job;
  }

  // 删除职位（不变）
  async destroy(id) {
    const { ctx } = this;
    const job = await ctx.model.Job.findByPk(id);
    if (!job) {
      throw new Error('职位不存在');
    }

    const currentUserId = ctx.state.user_id;
    const isAdmin = ctx.state.type === 'admin';
    if (!currentUserId || (!isAdmin && job.publisher_id.toString() !== currentUserId.toString())) {
      throw new Error('无权删除此职位（非发布者或管理员）');
    }

    await job.destroy();
    return true;
  }

  // 创建职位（不变）
  async create(data) {
    const { ctx } = this;
    return ctx.model.Job.create({
      ...data,
      created_at: new Date(),
    });
  }

  // 申请职位（不变）
  async apply({ job_id, user_id, resume_id }) {
    const { ctx } = this;
    const job = await ctx.model.Job.findByPk(job_id);
    if (!job) {
      throw new Error('职位不存在');
    }

    const resume = await ctx.model.Resume.findOne({
      where: { resume_id, user_id },
    });
    if (!resume) {
      throw new Error('简历不存在');
    }

    return ctx.model.JobApplication.create({
      job_id,
      user_id,
      resume_id,
      applied_at: new Date(),
    });
  }
}

module.exports = JobService;